// 版权所有2011 Go作者。版权所有。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

/*
	Package builtin provides documentation for Go's predeclared identifiers.
	The items documented here are not actually in package builtin
	but their descriptions here allow godoc to present documentation
	for the language's special identifiers.
*/
package builtin

// bool是布尔值的集合，true和false。
type bool bool

// true和false是两个非类型化的布尔值。
const (
	true  = 0 == 0 // 非类型布尔。
	false = 0 != 0 // 非类型布尔。
)

// uint8是所有无符号8位整数的集合。
// 范围：0到255。
type uint8 uint8

// uint16是所有无符号16位整数的集合。
// 范围：0到65535。
type uint16 uint16

// uint32是所有无符号32位整数的集合。
// 范围：0到4294967295。
type uint32 uint32

// uint64是所有无符号64位整数的集合。
// 范围：0到18446744073709551615。
type uint64 uint64

// int8是所有有符号8位整数的集合。
// 范围：-128到127。
type int8 int8

// int16是所有有符号16位整数的集合。
// 范围：-32768到32767。
type int16 int16

// int32是所有有符号32位整数的集合。
// 范围：-2147483648到2147483647。
type int32 int32

// int64是所有有符号64位整数的集合。
// 范围：-9223372036854775808到9223372036854775807。shu jian defg
type int64 int64

type float32 float32

// float64是所有IEEE-754 64位浮点数的集合。
type float64 float64

// complex64是所有复数的集合，实数为32，虚部为61
type complex64 complex64

// complex128是所有复数的集合，具有浮点64实部和
// 虚部。
type complex128 complex128

// string是8位字节的所有字符串的集合，按惯例，但不一定代表UTF-8编码的文本。字符串可以为空，但
// 不能为空。字符串类型的值是不可变的。
type string string

// int是一种大小至少为32位的有符号整数类型。然而，它是
// 独特类型，而不是int32的别名。
type int int

// uint是一种大小至少为32位的无符号整数类型。然而，它是
// 独特类型，而不是uint32的别名。
type uint uint

// uintptr是一个整数类型，其大小足以容纳
// 任何指针的位模式。
type uintptr uintptr

// 字节是uint8的别名，在所有方面都与uint8等效。按照惯例，它是
// 用于区分字节值和8位无符号
// 整数值。
type byte = uint8

// 符文是int32的别名，在所有方面都等同于int32。根据惯例，它是
// 用于区分字符值和整数值。
type rune = int32

// any是接口{}的别名，在所有方面都与接口{}等价。
type any = interface{}

// comparable是一个由所有可比较类型
// （布尔、数字、字符串、指针、通道、可比较类型的数组、
// 字段均为可比较类型的结构）实现的接口。
// 可比接口只能用作类型参数约束，
// 不能用作变量类型。
type comparable interface{ comparable }

// iota是一个预先声明的标识符，表示当前常量规范（通常用括号括起来）
// 编号。它是零索引的。
// 常量声明中的非类型整数序号
const iota = 0 // Untyped int.

// nil是一个预先声明的标识符，表示
// 指针、通道、函数、接口、映射或切片类型的零值。
var nil Type // 类型必须是指针、通道、函数、接口、映射或切片类型

// 这里的类型仅供文档使用。对于任何Go类型，它都是
// 的替代，但对于任何给定函数
// 调用，它都代表相同的类型。
type Type int

// Type1仅用于文档编制。对于任何Go类型，它都是
// 的替代，但对于任何给定函数
// 调用，它都代表相同的类型。
type Type1 int

// 此处的IntegerType仅供参考。它是
// 的替代品，适用于任何整数类型：int、uint、int8等。
type IntegerType int

// FloatType仅用于文档编制。它是
// 中的一个替代项，用于浮点数类型：float32或float64。
type FloatType float32

// 这里的ComplexType仅供参考。它是一个
// 代表复杂类型：complex64或complex128。
type ComplexType complex64

// append内置函数将元素追加到片段的末尾。如果
// 它有足够的容量，目的地将被重新许可以容纳
// 新元素。否则，将分配一个新的底层数组。
// Append返回更新的切片。因此，有必要将append的
// 结果存储在保存切片本身的变量中：
// slice=append（slice，elem1，elem2）
// slice=append（slice，anotherSlice…）
// 作为一种特殊情况，向字节片追加字符串是合法的，如下所示：
// slice=append（[]字节（“hello”），“world”…）
func append(slice []Type, elems ...Type) []Type

// 复制内置函数将源片中的元素复制到目标片中。（作为特例，它还将把
// 字符串中的字节复制到字节片中。）源和目标可能重叠。Copy 
// 返回复制的元素数，它将是
// len（src）和len（dst）的最小值。
func copy(dst, src []Type) int

// delete内置函数从映射中删除具有指定键
// （m[键]）的元素。如果m为nil或没有这样的元素，delete 
// 是不可操作的。
func delete(m map[Type]Type1, key Type)

// len内置函数根据其类型返回v的长度：
// 数组：v中的元素数。
// 指向数组的指针：v中的元素数（即使v为零）。
// 切片或映射：v中的元素数；如果v为零，len（v）为零。
// 字符串：v中的字节数。
// 通道：通道缓冲区中排队（未读）的元素数；
// 如果v为零，则len（v）为零。
// 对于某些参数，例如字符串文字或简单数组表达式，
// 结果可以是常量。有关详细信息，请参见Go语言规范的“长度和
// 容量”部分。
func len(v Type) int

// cap内置函数根据类型返回v的容量：
// 数组：v中的元素数（与len（v）相同）。
// 指向数组的指针：*v中的元素数（与len（v）相同）。
// 切片：重新切片时切片可以达到的最大长度；
// 如果v为零，则上限（v）为零。
// 信道：信道缓冲容量，以元素为单位；
// 如果v为零，则上限（v）为零。
// 对于某些参数，例如简单的数组表达式，结果可以是
// 常量。有关
// 的详细信息，请参见Go语言规范的“长度和容量”部分。
func cap(v Type) int

// make内置函数分配并初始化类型为
// 切片、映射或chan（仅限）的对象。与new一样，第一个参数是一个类型，而不是
// 值。与new不同，make的返回类型与其
// 参数的类型相同，而不是指向它的指针。结果的规格取决于
// 类型：
// 切片：大小指定长度。切片的容量为
// 等于其长度。第二个整数参数可以提供给
// 指定不同的容量；其长度不得小于
// 长度。例如，make（[]int，0，10）分配一个大小为10的底层数组
// 并返回一个长度为0、容量为10的片，该片由该底层数组支持。
// 映射：为空映射分配足够的空间来容纳指定数量的元素。大小可以省略，在这种情况下
// 分配一个小的起始大小。
// 通道：使用指定的
// 缓冲容量初始化通道的缓冲区。如果为零，或省略了大小，则通道为
// 无缓冲。
func make(t Type, size ...IntegerType) Type

// 新的内置函数分配内存。第一个参数是一个类型，
// 不是一个值，返回的值是指向新分配的该类型的零值的指针。
func new(Type) *Type

// 复杂内置函数从两个
// 浮点值构造一个复杂值。实部和虚部必须具有相同的
// 大小，可以是float32或float64（或可分配给它们），返回的
// 值将是相应的复数类型（complex64表示float32，
// complex128表示float64）。
func complex(r, i FloatType) ComplexType

// 实数内置函数返回复数c的实部。
// 返回值将是与c的类型对应的浮点类型。
func real(c ComplexType) FloatType

// imag内置函数返回复数
// 数字c的虚部。返回值将是与
// 对应的浮点类型c.
func imag(c ComplexType) FloatType

// 关闭内置函数关闭通道，该通道必须是
// 双向或仅发送。只能由发送方执行，而不能由接收方执行，并具有在收到最后发送的值后关闭通道的效果。在从封闭通道c接收到最后一个值
// 后，任何从c接收的操作都将成功，而不会出现
// 阻塞，返回通道元素的零值。
// x，ok:=<-c 
// 表格也会将关闭通道的ok设置为false。
func close(c chan<- Type)

// panic内置函数停止当前
// goroutine的正常执行。当函数F调用panic时，F的正常执行会立即停止
// 。任何被F延迟执行的函数都以通常的方式在
// /中运行，然后F返回给它的调用者。对调用方G来说，对F的
// 调用的行为就像对panic的调用，终止G的
// 执行并运行任何延迟的函数。这将一直持续到执行goroutine中的所有
// 函数按相反顺序停止为止。在
// 此时，程序以非零退出代码终止。此
// 终止序列称为恐慌，可由
// 内置函数recover控制。
func panic(v any)

// 恢复内置函数允许程序管理惊慌失措的goroutine的行为。在延迟的
// 函数（但不是它调用的任何函数）中执行恢复调用，通过恢复正常执行停止恐慌序列
// 并检索传递给恐慌调用
// 的错误值。如果在延迟函数之外调用recover，它将
// 不会停止恐慌序列。在这种情况下，或者当goroutine不是
// panicking，或者如果提供给panic的参数是nil，recover返回
// nil。因此，recover的返回值报告goroutine是否为
// 恐慌。
func recover() any

// 打印内置函数以特定于实现的方式格式化其参数，并将结果写入标准错误。
// 打印对于引导和调试非常有用；
// 不保证继续使用该语言。
func print(args ...Type)

// println内置函数以特定于实现的方式格式化其参数，并将结果写入标准错误。
// 始终在参数之间添加空格，并添加换行符。
// Println对于引导和调试非常有用；
// 不保证继续使用该语言。
func println(args ...Type)

// 错误内置接口类型是
// 的常规接口，表示错误条件，nil值表示无错误。
type error interface {
	Error() string
}
